
#ifndef __M_SRV_H__
#define __M_SRV_H__
#include "db.hpp"
#include "log.hpp"
#include "match.hpp"
#include "room.hpp"
#include "onlineuser.hpp"
#include "session.hpp"
#include "util.hpp"

#define WEBROOT "./wwwroot/"

// 服务器搭建
class gobang_server
{
public:
    gobang_server(const std::string &host,
                  const std::string &username,
                  const std::string &passwd,
                  const std::string &dbname,
                  uint16_t port = 3306, const std::string webroot = WEBROOT)
        : _us_tb(host, username, passwd, dbname, port),
          _rm(&_online, &_us_tb),
          _session(&_server),
          _webroot(webroot),
          _match(&_online, &_us_tb, &_rm)
    {
        // 2,设置日志等级，禁止所有日志打印
        _server.set_access_channels(websocketpp::log::alevel::none);
        // 3，初始化asio调度器
        _server.init_asio();
        _server.set_reuse_addr(true); // 开启地址重用
        // 4,注册回调函数
        _server.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));      // http请求回调函数
        _server.set_open_handler(std::bind(&gobang_server::wsropen_callback, this, std::placeholders::_1));   // websocket握手成功回调函数
        _server.set_close_handler(std::bind(&gobang_server::wsrclose_callback, this, std::placeholders::_1)); // websocket断开连接回调函数
        _server.set_message_handler(std::bind(&gobang_server::wsrmsg_callback, this,
                                              std::placeholders::_1, std::placeholders::_2)); // websocket消息处理函数
    }
    void start(int port)
    {
        // 5，监听端口
        _server.listen(port);
        // 6，开始接受tcp连接
        _server.start_accept();
        // 7，启动服务器
        _server.run();
    }

private:
    void resp_helper(wsserver_t::connection_ptr &conn, bool result,
                     const std::string &reason, websocketpp::http::status_code::value code)
    {
        Json::Value resp; // 构建响应
        resp["result"] = result;
        resp["reason"] = reason;
        std::string resp_body;
        Json_util::seralize(resp, resp_body);
        conn->set_status(code);
        conn->append_header("Content-Type", "aplication/json");
        conn->set_body(resp_body);
    }
    // 处理静态资源的方法
    void handle_file(wsserver_t::connection_ptr &conn)
    {
        // 静态资源请求的处理
        // 1. 获取到请求uri-资源路径，了解客户端请求的页面文件名称
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        // 2. 组合出文件的实际路径   相对根目录 + uri
        std::string realpath = _webroot + uri;
        // 3. 如果请求的是个目录，增加一个后缀  login.html,    /  ->  /login.html
        if (realpath.back() == '/')
        {
            realpath += "login.html";
        }
        // 4. 读取文件内容
        Json::Value resp_json;
        std::string body;
        bool ret = file_util::read(realpath, body);
        //  1. 文件不存在，读取文件内容失败，返回404
        if (ret == false)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='UTF-8'/>";
            body += "</head>";
            body += "<body>";
            body += "<h1> Not Found </h1>";
            body += "</body>";
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        // 5. 设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
        // websocketpp::http::parser::request req = conn->get_request();
        // std::string uri = req.get_uri();
        // std::string realfile = _webroot + uri;
        // if (realfile.back() == '/')
        // {
        //     // 请求根目录，返回登录页面
        //     realfile += "login.html";
        // }
        // std::string body;
        // bool ret = file_util::read(realfile, body);
        // if (ret == false)
        // {
        //     // 读取文件失败，即请求的资源不存在，返回404页面
        //     realfile = _webroot + "404.html";
        //     file_util::read(realfile, body);
        //     conn->set_status(websocketpp::http::status_code::value::not_found);
        //     conn->append_header("Content-Type", "text/html");
        //     conn->set_body(body);
        //     return;
        // }
        // conn->set_status(websocketpp::http::status_code::value::ok);
        // conn->set_body(body);
    }
    // 用户登录功能
    void login(wsserver_t::connection_ptr &conn)
    {
        // 用户发送的请求正文中以json的形式组织username和password
        // websocketpp::http::parser::request req = conn->get_request();
        std::string body = conn->get_request_body();
        Json::Value user;
        // 1.反序列化获取用户的username和password信息
        bool ret = Json_util::parse(body, user);
        if (ret == false)
        {
            DLOG("反序列化失败");
            return resp_helper(conn, false, "请求的正文格式错误!!", websocketpp::http::status_code::value::bad_request);
        }

        // 2.检验信息的完整性
        if (user["username"].isNull() || user["password"].isNull())
        {
            DLOG("用户名或密码不完整");
            return resp_helper(conn, false, "username/password为空", websocketpp::http::status_code::value::bad_request);
        }
        // 3.进行数据匹配
        ret = _us_tb.login(user);
        if (ret == false)
        {
            DLOG("用户名或密码错误");
            return resp_helper(conn, false, "username/password error!!", websocketpp::http::status_code::value::bad_request);
        }
        // 4,登录成功，给客户端创建session
        uint64_t uid = user["id"].asUInt64();
        session::ptr ssp = _session.create_session(uid, statu::LOGIN);
        if (ssp.get() == nullptr)
        {
            DLOG("创建会话失败");
            return resp_helper(conn, false, "会话创建失败!!", websocketpp::http::status_code::value::internal_server_error);
        }
        _session.set_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);

        // 5.设置头部响应字段
        std::string cookie_sid = "SSID=" + std::to_string(ssp->get_ssid());
        conn->append_header("Set-Cookie", cookie_sid);
        return resp_helper(conn, true, "登录成功!!", websocketpp::http::status_code::value::ok);
    }

    // 用户注册功能
    void reg(wsserver_t::connection_ptr &conn)
    {
        // 用户发送的请求正文中以json的形式组织username和password
        // websocketpp::http::parser::request req = conn->get_request();
        // std::string body = req.get_body();
        std::string body = conn->get_request_body();
        Json::Value user;
        // 反序列化获取用户的username和password信息
        bool ret = Json_util::parse(body, user);
        if (ret == false)
        {
            DLOG("反序列化失败");
            return resp_helper(conn, false, "请求的正文格式错误!!", websocketpp::http::status_code::value::bad_request);
        }

        // 进行用户注册工作，将信息加入到数据库中
        if (user["username"].isNull() || user["password"].isNull())
        {
            DLOG("用户名或密码不完整");
            return resp_helper(conn, false, "username/password为空", websocketpp::http::status_code::value::bad_request);
        }
        ret = _us_tb.insert(user);
        if (ret == false)
        {
            DLOG("向数据库中插入数据失败");
            return resp_helper(conn, false, "用户名已被占用", websocketpp::http::status_code::value::bad_request);
        }
        return resp_helper(conn, true, "用户注册成功", websocketpp::http::status_code::value::ok);
    }
    bool get_cookie_val(const std::string &cookie_str, const std::string &key, std::string &val)
    {
        // cookie: SSID=XXX ; path=XXX
        // 1.以;  为分割符得到key=val的结构
        std::string sep = "; ";
        std::vector<std::string> result;
        string_util::split(cookie_str, sep, result);
        for (auto str : result)
        {
            // 2.以=为分割符 得到key 和 val
            std::vector<std::string> tmp;
            string_util::split(str, "=", tmp);
            if (tmp.size() != 2)
            {
                continue;
            }
            if (tmp[0] == key)
            {
                val = tmp[1];
                return true;
            }
        }
        return false;
    }
    // 获取用户信息功能
    void info(wsserver_t::connection_ptr &conn)
    {
        // 1.获取请求信息中的cookie
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            return resp_helper(conn, false, "找不到cookie!", websocketpp::http::status_code::value::bad_request);
        }
        // 2.从cookie中提取出ssid
        std::string ssid;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid);
        if (ret == false)
        {
            return resp_helper(conn, false, "找不到ssid!", websocketpp::http::status_code::value::bad_request);
        }
        // 3.在session管理中查找会话信息
        session::ptr ssp = _session.get_session(std::stol(ssid));
        if (ssp.get() == nullptr)
        {
            return resp_helper(conn, false, "session已过期,请重新登录!", websocketpp::http::status_code::value::bad_request);
        }
        // 4.在数据库中查找对应的用户信息
        uint64_t uid = ssp->getUid();
        Json::Value user_info;
        ret = _us_tb.select_by_id(uid, user_info);
        if (ret == false)
        {
            return resp_helper(conn, false, "用户信息不存在", websocketpp::http::status_code::value::bad_request);
        }

        // 5.组织响应
        std::string body; // #############1body的内容为true，已解决：序列化时出现问题
        Json_util::seralize(user_info, body);
        // std::cout << "user_info: " << user_info.toStyledString() << std::endl;
        conn->set_body(body);
        conn->append_header("Content-Type", "aplication/json");
        conn->set_status(websocketpp::http::status_code::value::ok);

        // 6.更新过期时间
        _session.set_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
    }
    // 收到http请求的回调处理函数
    void http_callback(websocketpp::connection_hdl hdl)
    {
        // 1,收到http请求后，根据请求的类型，进行响应
        wsserver_t::connection_ptr conn = _server.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();

        if (req.get_method() == "POST" && req.get_uri() == "/login")
        {
            // 上传用户信息进行登录验证
            login(conn);
        }
        else if (req.get_method() == "POST" && req.get_uri() == "/reg")
        {
            // 上传用户信息进行注册
            reg(conn);
        }
        else if (req.get_method() == "GET" && req.get_uri() == "/info")
        {
            // 获取用户信息的请求
            info(conn);
        }
        else
        {
            // 处理获取静态资源的请求
            handle_file(conn);
        }
    }

    // websocket连接的通用响应
    void ws_resp(wsserver_t::connection_ptr &conn, Json::Value &resp)
    {
        std::string body;
        Json_util::seralize(resp, body);
        if (conn.get() != nullptr && conn->get_state() == websocketpp::session::state::open)
        {
            conn->send(body);
        }
    }
    session::ptr get_session_by_cookie(wsserver_t::connection_ptr &conn)
    {
        Json::Value err_resp;
        // 1.验证登录
        //  1.获取请求信息中的cookie
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "找不到cookie!";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session::ptr();
        }
        //  2.从cookie中提取出ssid
        std::string ssid;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid);
        if (ret == false)
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "找不到ssid!";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session::ptr();
        }
        //  3.在session管理中查找会话信息
        session::ptr ssp = _session.get_session(std::stol(ssid));
        if (ssp.get() == nullptr)
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "session已过期,请重新登录!";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session::ptr();
        }
        return ssp;
    }
    // 进入游戏大厅建立的长连接
    void wsopen_game_hall(wsserver_t::connection_ptr &conn)
    {
        // 进行身份验证
        session::ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.判断用户是否重复登录
        Json::Value err_resp;
        if (_online.is_in_game_hall(ssp->getUid()) || _online.is_in_game_room(ssp->getUid()))
        {
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "玩家重复登录!";
            err_resp["result"] = false;
            return ws_resp(conn, err_resp);
        }
        // 3.将当前玩家以及conn加入到在线用户管理中
        _online.enter_game_hall(ssp->getUid(), conn);
        // 4.给客户端发送游戏大厅建立成功的响应
        Json::Value resp;
        resp["optype"] = "hall_ready";
        resp["result"] = true;
        resp["reason"] = "进入游戏大厅成功!";
        std::string body;
        Json_util::seralize(resp, body);
        if (conn.get() != nullptr && conn->get_state() == websocketpp::session::state::open)
        {
            conn->send(body);
        }

        // 5.将这个用户对应的session信息设置为永久存在
        _session.set_expire_time(ssp->get_ssid(), SESSION_FOREVER);
    }
    // 进入游戏房间的回调函数
    void wsopen_game_room(wsserver_t::connection_ptr &conn)
    {
        Json::Value resp;
        // 1.获取session信息
        session::ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.判断当前用户是否已经在线
        if (_online.is_in_game_hall(ssp->getUid()) || _online.is_in_game_room(ssp->getUid()))
        {
            resp["optype"] = "room_ready";
            resp["result"] = false;
            resp["reason"] = "用户重复登录!";
            return ws_resp(conn, resp);
        }
        // 3.判断当前用户是否已经创建好了房间
        room::ptr rp = _rm.get_room_by_uid(ssp->getUid());
        if (rp.get() == nullptr)
        {
            resp["optype"] = "room_ready";
            resp["result"] = false;
            resp["reason"] = "房间创建失败!";
            return ws_resp(conn, resp);
        }
        // 4.将当前用户添加到在线用户管理中
        _online.enter_game_room(ssp->getUid(), conn);
        // 5.将该session设置为永久存在
        _session.set_expire_time(ssp->get_ssid(), SESSION_FOREVER);
        // 6.向客户端响应
        resp["optype"] = "room_ready";
        resp["result"] = true;
        resp["uid"] = ssp->getUid();
        resp["white_id"] = rp->get_white_user();
        resp["black_id"] = rp->get_black_user();
        resp["room_id"] = rp->get_roomid(); // ########4buf：未返回房间号，导致在下棋的时候出现房间号不一致问题
        return ws_resp(conn, resp);
        // 发送的响应是room_info,包含自身id，白棋id和黑棋id
    }
    // websocket握手成功的回调函数
    void wsropen_callback(websocketpp::connection_hdl hdl)
    {
        // 长连接建立成功:进入游戏大厅的长连接，进入游戏房间的长连接
        wsserver_t::connection_ptr conn = _server.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string url = req.get_uri();
        if (url == "/hall")
        {
            return wsopen_game_hall(conn);
        }
        else if (url == "/room")
        {
            return wsopen_game_room(conn);
        }
    }
    // 游戏大厅连接断开处理函数
    void wsclose_game_hall(wsserver_t::connection_ptr &conn)
    {
        // 进行身份验证
        session::ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 1.从在线用户管理中移除该连接
        _online.exit_game_hall(ssp->getUid());
        // 2.将对应的会话设置过期时间
        _session.set_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
    }
    // 退出游戏房间的回调函数
    void wsclose_game_room(wsserver_t::connection_ptr &conn)
    {
        Json::Value resp;
        // 1.首先通过session获取用户信息
        session::ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.从在线用户管理中移除该用户信息
        _online.exit_game_room(ssp->getUid());
        // 3.将对应的session重新设置过期时间
        _session.set_expire_time(ssp->get_ssid(), SESSION_TIMEOUT);
        // 从房间管理中移除该用户
        _rm.remove_Room_user(ssp->getUid());
    }
    // websocket断开连接的回调函数
    void wsrclose_callback(websocketpp::connection_hdl hdl)
    {
        // 同样,连接断开也分为游戏大厅连接断开,游戏房间连接断开
        wsserver_t::connection_ptr conn = _server.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string url = req.get_uri();
        if (url == "/hall")
        {
            // ##################2又是一个bug,一致进入大厅，导致重复登录问题
            wsclose_game_hall(conn);
        }
        else if (url == "/room")
        {
            wsclose_game_room(conn);
        }
    }
    // 游戏大厅收到消息的回调函数(收到的消息：开始匹配/停止匹配)
    void wsmsg_game_hall(wsserver_t::connection_ptr &conn, wsserver_t::message_ptr &msg)
    {
        Json::Value resp;
        // 进行身份验证
        session::ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 首先获取到websocket协议的消息
        std::string msg_str = msg->get_payload();
        Json::Value req;
        bool ret = Json_util::parse(msg_str, req);
        if (ret == false)
        {
            resp["result"] = false;
            resp["reason"] = "反序列化失败";
            return ws_resp(conn, resp);
        }
        // ###################3又来一个bug
        // 在获取json中的值时，使用asCString导致与预期的字符不匹配
        // asCString返回的是指向jsoncpp内部的字符串指针
        //  当原json对象被销毁或修改时，指针可能失效
        if (!req["optype"].isNull() && req["optype"].asString() == "match_start")
        {
            // 开始匹配的请求,将用户加入到匹配模块中
            _match.add(ssp->getUid());
            resp["result"] = true;
            resp["optype"] = "match_start";
            return ws_resp(conn, resp);
        }
        else if (!req["optype"].isNull() && req["optype"].asString() == "match_stop")
        {
            // 停止匹配的请求
            _match.del(ssp->getUid());
            resp["result"] = true;
            resp["optype"] = "match_stop";
            return ws_resp(conn, resp);
        }

        resp["result"] = false;
        resp["optype"] = "unknow";
        return ws_resp(conn, resp);
    }
    // 游戏房间收到请求的回调函数
    void wsmsg_game_room(wsserver_t::connection_ptr &conn, wsserver_t::message_ptr &msg)
    {
        Json::Value resp;
        // 1.获取session信息
        session::ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2.获取房间信息
        room::ptr rp = _rm.get_room_by_uid(ssp->getUid());
        if (rp.get() == nullptr)
        {
            resp["optype"] = "unknow";
            resp["result"] = false;
            resp["reason"] = "房间不存在";
            return ws_resp(conn, resp);
        }
        // 3.对消息进行反序列化
        Json::Value req;
        std::string msg_str = msg->get_payload();
        bool ret = Json_util::parse(msg_str, req);
        if (ret == false)
        {
            resp["optype"] = "unknow";
            resp["result"] = false;
            resp["reason"] = "消息类型未知";
            return ws_resp(conn, resp);
        }
        // 4.进行请求的处理(下棋请求/聊天请求),通过房间类
        rp->handle_req(req);
    }
    // 收到websocket消息的回调处理函数
    void wsrmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        // 游戏大厅收到消息和游戏房间收到消息
        wsserver_t::connection_ptr conn = _server.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string url = req.get_uri();
        if (url == "/hall")
        {
            wsmsg_game_hall(conn, msg);
        }
        else if (url == "/room")
        {
            wsmsg_game_room(conn, msg);
        }
    }

private:
    wsserver_t _server;
    std::string _webroot;    // web根目录
    user_table _us_tb;       // 用户信息管理
    online_user _online;     // 在线用户管理
    roomManager _rm;         // 房间信息管理
    sessionManager _session; // session管理
    matchManager _match;
};

#endif